package com.mark.web.data.service.impl;

import com.google.common.collect.Lists;
import com.mark.common.ServerResponse;
import com.mark.web.data.mapper.CartMapper;
import com.mark.web.data.mapper.ProductMapper;
import com.mark.web.data.enums.CartEnum;
import com.mark.common.enums.PropertiesEnum;
import com.mark.common.exception.Campuso2oException;
import com.mark.web.data.entity.po.Cart;
import com.mark.web.data.entity.po.Product;
import com.mark.web.data.service.ICartService;
import com.mark.common.utils.BigDecimalUtil;
import com.mark.common.utils.PropertiesUtil;
import com.mark.web.data.entity.vo.CartProductVo;
import com.mark.web.data.entity.vo.CartVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.List;

/**
 * @Description: 购物车业务逻辑实现
 * @Author: Mark
 * @CreateDate: 2018/8/14.
 * @Version: 2.0
 * @Copyright : 豆浆油条个人非正式工作室
 */
@Service("cartServiceImpl")
@Slf4j
public class CartServiceImpl implements ICartService {
    @Autowired
    private CartMapper cartMapper;
    @Autowired
    private ProductMapper productMapper;

    @Override
    public ServerResponse<CartVo> getCartList(Integer userId){
        try{
            CartVo cartVo = getCartVoLimit(userId);
            return ServerResponse.createBySuccess(cartVo);
        }catch(Exception e){
            throw new Campuso2oException("获取购物列表",e);
        }
    }

    @Override
    public ServerResponse addProductToCart(Integer userId, Integer productId, Integer count){
        try {
            //1.查看购物车是否已经存在该商品
            Cart cart = cartMapper.selectCartByUserIdProductId(userId, productId);

            //如果该商品对应的购物车信息不存在，则新增记录
            if (cart == null) {
                Cart cartItem = new Cart();
                cartItem.setUserId(userId);
                cartItem.setProductId(productId);
                cartItem.setQuantity(count);
                Product product =  productMapper.selectByPrimaryKey(productId);
                if(product != null){
                    cartItem.setSellerId(product.getOwnerId());
                }
                //设置商品的状态为已勾选
                cartItem.setChecked(CartEnum.CHECKED.getState());
                cartMapper.insert(cartItem);
            } else {
                //已经存在，则更新数量
                count += cart.getQuantity();
                Product product = productMapper.selectByPrimaryKey(productId);
                if(product.getProductStock() < count){
                    return ServerResponse.createByErrorMessage("唯一的"+product.getProductStock()+"(件)商品已经加入你的购物车了！");
                }
                cart.setQuantity(count);
                cartMapper.updateByPrimaryKeySelective(cart);
            }
            return ServerResponse.createBySuccess("加入购物车成功");
        }catch (Exception e){
            throw new Campuso2oException("添加商品到购物车",e);
        }
    }

    @Override
    public ServerResponse<CartVo> updateCart(Integer userId, Integer productId, Integer count) {
        try {
            Cart cart = cartMapper.selectCartByUserIdProductId(userId, productId);
            if (cart != null) {
                cart.setQuantity(count);
                cartMapper.updateByPrimaryKeySelective(cart);
            } else {
                return ServerResponse.createByErrorMessage("更新商品不存在！");
            }
            return getCartList(userId);
        }catch (Exception e){
            throw new Campuso2oException("更新购物车中的商品",e);
        }
    }

    @Override
    public ServerResponse<CartVo> deleteProduct(Integer userId, List<String> productList) {
        try {
            cartMapper.deleteByUserIdProductIds(userId, productList);
            return getCartList(userId);
        }catch (Exception e){
            throw new Campuso2oException("移除购物车中的商品",e);
        }
    }

    @Override
    public ServerResponse<CartVo> selectOrUnSelect(Integer userId, Integer productId, Integer checked) {
        try {
            cartMapper.checkedOrUncheckedProduct(userId, productId, checked);
            return getCartList(userId);
        }catch (Exception e){
            throw new Campuso2oException("购物车商品选中状态的改变",e);
        }
    }


    @Override
    public ServerResponse<Integer> getCartProductCount(Integer userId) {
        try{
            Integer resultCount = cartMapper.selectCartProductCount(userId);
            return ServerResponse.createBySuccess(resultCount);
        }catch(Exception e){
            throw new Campuso2oException("获取购物车的商品数量",e);
        }
    }

    /**
     * -----------------------------------------------------------------------------------------------------------------
     * 私有方法（private method）
     * -----------------------------------------------------------------------------------------------------------------
     */
    /**
     * 1.根据用户id构建购物车的VO对象
     * @param userId：当前的用户id
     * @return ：
     */
    private CartVo getCartVoLimit(Integer userId) {
        try {
            CartVo cartVo = new CartVo();
            List<CartProductVo> cartProductVoList = Lists.newArrayList();

            //根据索引userId查找该用户在购物车表中的所有信息
            List<Cart> cartList = cartMapper.selectCartByUserId(userId);
            //被选中商品的总价格
            BigDecimal cartTotalPrice = new BigDecimal("0");

            //如果购物车表中存在用户记录
            if (CollectionUtils.isNotEmpty(cartList)) {
                //遍历构建 商品信息和购物信息 结合的实体类
                for (Cart cartItem : cartList) {
                    CartProductVo cartProductVo = new CartProductVo();
                    cartProductVo.setId(cartItem.getId());
                    cartProductVo.setUserId(cartItem.getUserId());
                    cartProductVo.setProductId(cartItem.getProductId());

                    //根据cartItem中的商品Id在商品表中查找商品信息
                    Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
                    //构建商品相关属性
                    if (product != null) {
                        cartProductVo.setProductName(product.getProductName());
                        cartProductVo.setProductSubtitle(product.getProductSubtitle());
                        cartProductVo.setProductMainImage(product.getMainImgAddr());
                        cartProductVo.setProductStatus(product.getEnableStatus());
                        //价格的处理
                        BigDecimal price = product.getPromotionPrice();
                        if (price != null) {
                            cartProductVo.setProductPrice(price);
                        } else {
                            cartProductVo.setProductPrice(product.getNormalPrice());
                        }
                        //库存量
                        cartProductVo.setProductStock(product.getProductStock());

                        //购物车中商品的数量实时重新赋值（业务中商品的库存量是变化的）
                        int buyLimitCount;
                        //如果商品的库存量大于购物车中商品的库存量
                        if (product.getProductStock() >= cartItem.getQuantity()) {
                            buyLimitCount = cartItem.getQuantity();
                            cartProductVo.setLimitQuantity(CartEnum.LIMIT_NUM_SUCCESS.getInformation());
                        } else {//库存量不足
                            log.warn("库存量不足！");
                            buyLimitCount = product.getProductStock();
                            cartProductVo.setLimitQuantity(CartEnum.LIMIT_NUM_FAIL.getInformation());
                            //购物车更新有效库存
                            Cart cartForQuantity = new Cart();
                            cartForQuantity.setId(cartItem.getId());
                            cartForQuantity.setQuantity(buyLimitCount);
                            cartMapper.updateByPrimaryKeySelective(cartForQuantity);
                        }
                        cartProductVo.setQuantity(buyLimitCount);
                        cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(cartProductVo.getProductPrice().doubleValue(), cartItem.getQuantity()));
                        int check = cartItem.getChecked();
                        if(check == CartEnum.CHECKED.getState()){
                            cartProductVo.setProductChecked(true);
                        }else if(check == CartEnum.UN_CHECKED.getState()){
                            cartProductVo.setProductChecked(false);
                        }
                    }
                    //如果购物车中商品被选中,统计总价
                    if (cartItem.getChecked() == CartEnum.CHECKED.getState()) {
                        cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(), cartProductVo.getProductTotalPrice().doubleValue());
                    }
                    cartProductVoList.add(cartProductVo);
                }
            }
            //购物车选中商品的总价格
            cartVo.setCatTotalPrice(cartTotalPrice);
            cartVo.setCartProductVoList(cartProductVoList);
            //所有的商品是否全选
            cartVo.setAllChecked(getAllCheckedStatus(userId));
            cartVo.setImageHost(PropertiesUtil.getProperty(PropertiesEnum.FTP_SERVICE_HTTP_PREFIX.getPropertiesName()));
            return cartVo;
        }catch (Exception e){
            throw new Campuso2oException("查看购物车信息",e);
        }
    }

    /**
     * 判断购物车中商品是否全都选中
     *
     * @param userId:当前的用户ID
     * @return
     */
    private Boolean getAllCheckedStatus(Integer userId) {
        if (userId == null){
            return false;
        }
        return cartMapper.selectCartProductCheckedStatusByUserId(userId) == 0;
    }
}
